package cn.com.anypay.manager.service;

import cn.com.anypay.manager.dto.request.WeChatBindRequestDTO;
import cn.com.anypay.manager.miaoma.sysuser.SysUserEntity;
import cn.com.anypay.manager.service.auth.strategy.impl.WeChatAuthStrategy;
import cn.dev33.satoken.stp.StpUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Map;

/**
 * 微信账户管理服务
 * 负责微信账户的绑定、解绑等操作
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class WeChatAccountService {

    private final WeChatAuthStrategy weChatAuthStrategy;
    private final WeChatService weChatService;

    /**
     * 绑定微信账户到当前登录用户
     * 
     * @param request 绑定请求
     * @return 绑定结果
     */
    @Transactional
    public boolean bindWeChatAccount(WeChatBindRequestDTO request) {
        log.info("开始绑定微信账户到当前用户");

        try {
            // 获取当前登录用户ID
            Long userId = getCurrentUserId(request.getUserId());
            if (userId == null) {
                log.warn("无法获取当前用户ID");
                return false;
            }

            // 验证状态参数
            if (!weChatService.validateState(request.getState())) {
                log.warn("状态参数验证失败: state={}", request.getState());
                return false;
            }

            // 执行绑定操作
            boolean result = weChatAuthStrategy.bindWeChatAccount(userId, request.getCode());
            
            if (result) {
                log.info("成功绑定微信账户: userId={}", userId);
            } else {
                log.warn("绑定微信账户失败: userId={}", userId);
            }
            
            return result;

        } catch (Exception e) {
            log.error("绑定微信账户时发生异常", e);
            return false;
        }
    }

    /**
     * 解绑当前用户的微信账户
     * 
     * @return 解绑结果
     */
    @Transactional
    public boolean unbindWeChatAccount() {
        log.info("开始解绑当前用户的微信账户");

        try {
            // 获取当前登录用户ID
            Long userId = getCurrentUserId(null);
            if (userId == null) {
                log.warn("无法获取当前用户ID");
                return false;
            }

            // 执行解绑操作
            boolean result = weChatAuthStrategy.unbindWeChatAccount(userId);
            
            if (result) {
                log.info("成功解绑微信账户: userId={}", userId);
            } else {
                log.warn("解绑微信账户失败: userId={}", userId);
            }
            
            return result;

        } catch (Exception e) {
            log.error("解绑微信账户时发生异常", e);
            return false;
        }
    }

    /**
     * 解绑指定用户的微信账户
     * 
     * @param userId 用户ID
     * @return 解绑结果
     */
    @Transactional
    public boolean unbindWeChatAccount(Long userId) {
        log.info("开始解绑指定用户的微信账户: userId={}", userId);

        try {
            // 执行解绑操作
            boolean result = weChatAuthStrategy.unbindWeChatAccount(userId);
            
            if (result) {
                log.info("成功解绑微信账户: userId={}", userId);
            } else {
                log.warn("解绑微信账户失败: userId={}", userId);
            }
            
            return result;

        } catch (Exception e) {
            log.error("解绑微信账户时发生异常: userId={}", userId, e);
            return false;
        }
    }

    /**
     * 检查当前用户是否已绑定微信账户
     * 
     * @return 是否已绑定
     */
    public boolean isWeChatAccountBound() {
        try {
            Long userId = getCurrentUserId(null);
            if (userId == null) {
                return false;
            }
            
            return weChatAuthStrategy.isWeChatAccountBound(userId);
            
        } catch (Exception e) {
            log.error("检查微信账户绑定状态时发生异常", e);
            return false;
        }
    }

    /**
     * 检查指定用户是否已绑定微信账户
     * 
     * @param userId 用户ID
     * @return 是否已绑定
     */
    public boolean isWeChatAccountBound(Long userId) {
        try {
            return weChatAuthStrategy.isWeChatAccountBound(userId);
        } catch (Exception e) {
            log.error("检查微信账户绑定状态时发生异常: userId={}", userId, e);
            return false;
        }
    }

    /**
     * 获取当前用户绑定的微信账户信息
     * 
     * @return 微信账户信息
     */
    public Map<String, Object> getWeChatAccountInfo() {
        try {
            Long userId = getCurrentUserId(null);
            if (userId == null) {
                return null;
            }
            
            return weChatAuthStrategy.getWeChatAccountInfo(userId);
            
        } catch (Exception e) {
            log.error("获取微信账户信息时发生异常", e);
            return null;
        }
    }

    /**
     * 获取指定用户绑定的微信账户信息
     * 
     * @param userId 用户ID
     * @return 微信账户信息
     */
    public Map<String, Object> getWeChatAccountInfo(Long userId) {
        try {
            return weChatAuthStrategy.getWeChatAccountInfo(userId);
        } catch (Exception e) {
            log.error("获取微信账户信息时发生异常: userId={}", userId, e);
            return null;
        }
    }

    /**
     * 根据微信OpenID查找用户
     * 
     * @param openId 微信OpenID
     * @return 用户信息
     */
    public SysUserEntity findUserByOpenId(String openId) {
        try {
            return weChatAuthStrategy.findUserByOpenId(openId);
        } catch (Exception e) {
            log.error("根据OpenID查找用户时发生异常: openId={}", openId, e);
            return null;
        }
    }

    /**
     * 检查微信账户是否可以绑定到指定用户
     * 
     * @param userId 用户ID
     * @param code 微信授权码
     * @return 检查结果
     */
    public boolean canBindWeChatAccount(Long userId, String code) {
        try {
            // 这里可以添加更多的绑定前检查逻辑
            // 比如检查用户状态、权限等
            
            // 基本检查：用户是否存在且未绑定微信
            return !isWeChatAccountBound(userId);
            
        } catch (Exception e) {
            log.error("检查微信账户绑定条件时发生异常: userId={}", userId, e);
            return false;
        }
    }

    /**
     * 获取当前用户ID
     * 
     * @param providedUserId 提供的用户ID（可选）
     * @return 用户ID
     */
    private Long getCurrentUserId(Long providedUserId) {
        try {
            // 如果提供了用户ID，则使用提供的ID（需要权限验证）
            if (providedUserId != null) {
                // 这里可以添加权限检查，确保当前用户有权限操作指定用户
                // 暂时直接返回提供的用户ID
                return providedUserId;
            }
            
            // 否则获取当前登录用户的ID
            if (StpUtil.isLogin()) {
                return StpUtil.getLoginIdAsLong();
            }
            
            return null;
            
        } catch (Exception e) {
            log.error("获取当前用户ID时发生异常", e);
            return null;
        }
    }
}